/*
 * Copyright 2005-2013 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * 
 * Project website:
 *      http://www.cottsoft.com
 */
package com.cottsoft.framework.common.util;

import java.math.BigDecimal;
import java.text.NumberFormat;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import com.cottsoft.framework.common.flg.EDirection;
import com.cottsoft.framework.common.flg.IFlg;

/**
 * Class Description: <br> 
 * 
 * @author  Simon.Hoo(simon@cottsoft.com)
 * @date    2006年4月5日
 * @version v1.0
 * @since   1.0
 */
public class StringUtils implements IFlg {
	
	/**
	 * Description：<br> 
	 * 将一个整型数字格式化为一个指定长度的字符串返回，如果整型数字的长度小于字符串的指定长度，前面以传入
	 * 的字符进行补充,否则原样返回，如：formatInt2String(123,10,EDirection.LEFT,"0")，将返回：0000000123<br> 
	 * 如果leftOrRight不是EDirection.LEFT或者EDirection.RIGHT，则返回原值。
	 * @param data 要转换的整型数据
	 * @param length 指定字符串的长度
	 * @param dir 是在前面补充，还是在后面补充
	 * @param supplement 不够长度的以该字符进行补充
	 * @return string 格式化之后的字符串
	 */
	public static String formatInt2String(int data,int length,EDirection dir, String supplement){
		String returnString ="";
		String strData = String.valueOf(data);
		StringBuffer sb = new StringBuffer();
		int size = strData.length();
		if(size < length) {
			while(size++ < length){
				sb.append(supplement);
			}
			switch(dir){
				case LEFT:
					returnString = sb.append(strData).toString();
					break;
				case RIGHT:
					returnString = strData+sb.toString();
					break;
				default:
					returnString = strData;
			}	
		}else{
			returnString = strData;
		}		
		return returnString;
	}
	
	/**
	 * Description：<br> 
	 * 将一个字符串格式化为一个指定长度的字符串返回，如果整型数字的长度小于字符串的指定长度，前面以传入
	 * 的字符进行补充,否则原样返回，如：formatString2String(abc,10,EDirection.LEFT,"0")，将返回：0000000abc <br> 
	 * 如果leftOrRight不是EDirection.LEFT或者EDirection.RIGHT，则返回原值。
	 * @param strData 要转换的字符串
	 * @param length 指定字符串的长度
	 * @param dir 是在前面补充，还是在后面补充
	 * @param supplement 不够长度的以该字符进行补充
	 * @return string 格式化之后的字符串
	 */
	public static String formatString2String(String strData,int length,EDirection dir, String supplement){
		String returnString ="";
		StringBuffer sb = new StringBuffer();
		int size = strData.length();
		if(size < length) {
			while(size++ < length){
				sb.append(supplement);
			}
			switch(dir){
				case LEFT:
					returnString = sb.append(strData).toString();
					break;
				case RIGHT:
					returnString = strData+sb.toString();
					break;
				default:
					returnString = strData;
			}	
		}else{
			returnString = strData;
		}		
		return returnString;
	}
	
	/**
	 * Description：<br> 
	 * 将字符串中的回车、换行、制表符、空格全部去掉。<br> 
	 * 注：<br> 
	 * \n 回车(\u000a)、<br> 
	 * \t 水平制表符(\u0009)、<br> 
	 * \s 空格(\u0008)、<br> 
	 * \r 换行(\u000d)；<br> 
	 * @param data 要格式化的字符串
	 * @return 格式化之后的字符串
	 */
	public static String replaceBlank(String data) {  
		String dest = null;  
		if (data!=null) {  
			Pattern p = Pattern.compile("\\s*|\t|\r|\n");  
			Matcher m = p.matcher(data);  
			dest = m.replaceAll("");  
		}  
		return dest;  
	}
	
	/**
	 * Description：<br> 
	 * 格式化XML字符串,将所有的回车、换行、制表符去掉，转换为一行，同时如果">"和"<"之间
	 * 没有任何非空(" ")字符，则去掉空格。
	 * @param data 原始带有换行、回车、制表符的XML字符串
	 * @return 格式化之后仅一行的XML字符串
	 */
	public static String formatXmlStringOneLine(String data){
		String dest = null;  
		if(data!=null){
			dest = data.replaceAll("\t|\r|\n", "").replaceAll("> +<","><");
		}
		return dest;  
	}
	
	/**
	 * Description：<br> 
	 * 判断传入的字符串是否是整型数字(如果字符串为null或者空，则返回false)
	 * @param data 要判断的数字字符
	 * @return true/false
	 */
	public static boolean isIntNumberStr(String data){
		if (data != null && !data.equals("")) {
		    Pattern p = Pattern.compile("[0-9]*");
		    Matcher m = p.matcher(data);
		    return m.matches();
		} else {
			return false;
		}
	}
	
	/**
	 * Description：<br> 
	 * 将金额转换为字符串
	 * @param amount
	 * @param scale 表示保留位数
	 * @return 转换后的字符串
	 */
	public static String formatBigDecimal2String(BigDecimal amount,int scale){
		BigDecimal bd = amount.setScale(scale, BigDecimal.ROUND_HALF_UP); 
		
		return bd.toString();
	}
	
	/**
	 * Description：<br> 
	 * 将字符串转换为金额
	 * @param amount
	 * @return 转换后的金额
	 */
	public static BigDecimal formatString2BigDecimal(String amount){
		return new BigDecimal(amount);
	}
	
	/**
	 * Description：<br> 
	 * 将数字转换为字符串
	 * @param number
	 * @param rigthSize
	 * @return 转换后的字符串
	 */
	public static String formatInt2String(int number,int rigthSize){
		NumberFormat numberFormat = NumberFormat.getInstance();
		numberFormat.setMinimumFractionDigits(rigthSize);
		Double dbleInput = Double.valueOf(number);
		return numberFormat.format(dbleInput);
	}
	
	/**
	 * Description：<br> 
	 * 将小数原样转换为字符串
	 * @param number
	 * @param rigthSize
	 * @return 转换后的字符串
	 */
	public static String formatDouble2String(double number,int rigthSize){
         NumberFormat numberFormat = NumberFormat.getInstance();
         numberFormat.setMinimumFractionDigits(rigthSize);
         Double dbleInput = Double.valueOf(number);
         return numberFormat.format(dbleInput);
	}
	
	/**
	 * Description：<br> 
	 * 判断一个字符串是否在一个字符串数组内。
	 * @param str 字符串
	 * @param arry 字符串数组
	 * @return true/false
	 */
	public static boolean isStringInArray(String str,String[] arry){
		for(String arryUnit:arry){
			if(arryUnit.equals(str)){
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Description：<br> 
	 * 判断一个数字是否在一个数字数组内。
	 * @param nbr 数字
	 * @param arry 数字数组
	 * @return true/false
	 */
	public static boolean isIntegerInArray(Integer nbr,Integer[] arry){
		for(Integer arryUnit:arry){
			if(arryUnit.equals(nbr)){
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Description：<br> 
	 * 判断一个数字是否在一个数字List内。
	 * @param nbr 数字
	 * @param arry 数字数组
	 * @return true/false
	 */
	public static boolean isIntegerInList(Integer nbr,List<Integer> arry){
		for(Integer arryUnit:arry){
			if(arryUnit.equals(nbr)){
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Description：<br> 
	 * 判断一个数字是否在一个数字List内。
	 * @param nbr 数字
	 * @param arry 数字数组
	 * @return true/false
	 */
	public static boolean isBigIntegerInList(Integer nbr,List<Integer> arry){
		for(Integer arryUnit:arry){
			if(arryUnit.equals(nbr)){
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Description：<br> 
	 * 判断一个字符串是否在一个字符List内。 
	 * @param str 字符串
	 * @param strList 字符串LIST(list元素不能有null值)
	 * @return true/false
	 */
	public static boolean isStringInList(String str, List<String> strList){
		for(String arryUnit:strList){
			if(arryUnit.equals(str)){
				return true;
			}
		}
		return false;
	}
	
	/**
	 * Description：<br> 
	 * 获取随机字符串
	 * @param length 长度
	 * @return 随机数字符串
	 */
	public static String getRandomString(int length){
		Random random = new Random();
		StringBuilder sb = new StringBuilder();
        for(int i = 0; i <length ;i++) {
        	sb.append(Math.abs(random.nextInt()%10));
        }
        return sb.toString();
	}
	
	/**
	 * Description：<br>
	 * 判断字符串是否为NULL。
	 * @param str 要判断的字符串
	 * @return true/false
	 */
	public static boolean isNull(String str){
		return str==null?false:true;
	}
	
	/**
	 * Description：<br>
	 * 判断字符串是判断字符串是否为空值或NULL;
	 * @param str 要判断的字符串
	 * @return true/false
	 */
	public static boolean isBlankOrNull(String str){
		if(str==null || str.trim().length()==0){
			return true;
		}
		return false;
	}
	

	/**
	 * Description：<br>
	 * 返转字符串，如：123456返回654321
	 * @param s
	 * @return
	 */
	public static String reversionString(String s){
		char[] str = s.toCharArray(); 
		int begin = 0;  
		int end = s.length() - 1;  
		while (begin < end) {  
			str[begin] = (char) (str[begin] ^ str[end]);  
			str[end] = (char) (str[begin] ^ str[end]);  
			str[begin] = (char) (str[end] ^ str[begin]);  
			begin++;  
			end--;  
		}
		return new String(str); 
	}
	
	
	/**
	 * Description：<br>
	 * 将一个List<Integer>对象转换成了个字符串。
	 * @param intList
	 * @return
	 */
	public static String intList2String(List<Integer> intList){
		StringBuffer sb = new StringBuffer(intList.size());
		for(Integer it : intList){
			sb.append(it);
		}
		return sb.toString();
	}
	
	
	/**
	 * Description：<br>
	 * 将一个List<String>对象转换成了个字符串。
	 * @param strList
	 * @return
	 */
	public static String strList2String(List<String> strList){
		StringBuffer sb = new StringBuffer(strList.size());
		for(String it : strList){
			sb.append(it);
		}
		return sb.toString();
	}
	
	/**
	 * Description：<br>
	 * 将一个List<Map<Stirng,String>>对象转换成了个字符串。
	 * @param mapList
	 * @return
	 */
	public static String mapList2String(List<Map<String,String>> mapList){
		StringBuffer sb = new StringBuffer();
		for(Map<String,String> map : mapList){			
			Set<Entry<String, String>> set = map.entrySet();
			Iterator<Entry<String, String>> it=set.iterator();
			while(it.hasNext()){
				Map.Entry<String, String>  entry=(Entry<String, String>) it.next();
				sb.append(entry.getKey()+":"+entry.getValue()).append("\r\n");
			}  
		}
		return sb.toString();
	}
	
	/**
	 * Description：<br>
	 * 判断一个字符串是否是二进制
	 * @param str 原字符符串
	 * @return 判断结果
	 */
	public static boolean isBinNumber(String str){  
		String validate = "(?i)[0-1]+";  
		return str.matches(validate);  

	}  

	/**
	 * Description：<br>
	 * 判断一个字符串是否是十进制   
	 * @param str 原字符符串
	 * @return 判断结果
	 */
	public static boolean isDecmailNumber(String str) {  
		String validate = "(?i)[0-9]+";  
		return str.matches(validate);  
	}  

	
	/**
	 * Description：<br>
	 * 判断一个字符串是否是十六进制
	 * @param str 原字符符串
	 * @return 判断结果
	 */
	public static boolean isHexNumber(String str){  
		String validate = "(?i)[0-9a-f]+";  
		return str.matches(validate);  

	}  
	/**
	 * Description：<br>
	 * 判断字符串是否为数字（包含负数和小数的验证，不包含时间格式的验证）
	 * @param str 字符串
	 * @return
	 */
	public static boolean isNumber(String str){
		Pattern pattern = Pattern.compile("-?\\d+\\.?\\d*");
		Matcher matcher = pattern.matcher((CharSequence)str);
		 boolean result = matcher.matches();
		 if (result == true) {
			 return true;
		 }else{
			 return false;
		 }
	}
}


